/**
 *
 */
package com.zzq.my.jetpacks.jectpackapp.utils;

import static java.math.BigDecimal.ROUND_DOWN;

import android.text.TextUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;

/**
 * @author div 2015-11-20 TODO
 */
public class MathUtil {
    // 默认除法运算精度
    private static final int DEFAULT_DIV_SCALE = 10;

    private static final int digit = 2;// 保留小数的位数

    public static String twoNumber(int number) {
        BigDecimal bigDecimal = new BigDecimal(Integer.toString(number));
        return bigDecimal.setScale(digit, BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String twoNumber(float number) {
        BigDecimal bigDecimal = new BigDecimal(Float.toString(number));
        return bigDecimal.setScale(digit, BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String twoNumber(double number) {
        BigDecimal bigDecimal = new BigDecimal(Double.toString(number));
        return bigDecimal.setScale(digit, BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String twoNumber(String number) {
        if(null==number||TextUtils.isEmpty(number)){
            return "0.00";
        }
        BigDecimal bigDecimal = new BigDecimal(number);
        return bigDecimal.setScale(digit, BigDecimal.ROUND_HALF_UP).toString();
    }




    /**
     * 保留两位小数，进一法则
     * @param number
     * @return
     */
    public static String twoNumberUp(String number) {
        if(TextUtils.isEmpty(number)){
            return "0.00";
        }
        BigDecimal bigDecimal = new BigDecimal(number);
        return bigDecimal.setScale(digit, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1
     * @param v2
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数数学加和，以字符串格式返回
     */
    public static String add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).toString();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1
     * @param v2
     * @return 两个参数的差
     */
    public static double subtract(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数数学差，以字符串格式返回
     */
    public static String subtract(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).toString();
    }

    /**
     * 提供精确的乘法运算。
     *
     * @param v1
     * @param v2
     * @return 两个参数的积
     */
    public static double multiply(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1
     * @param v2
     * @return 两个参数的数学积，以字符串格式返回
     */
    public static String multiply(String v1, String v2) {
        if(TextUtils.isEmpty(v1)||TextUtils.isEmpty(v2)){
            return "0";
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).toString();
    }

//    /**
//     * 提供精确的乘法运算
//     *
//     * @param v1
//     * @param v2
//     * @return 两个参数的数学积，以字符串格式返回
//     */
//    public static BigDecimal multiply(String v1, String v2) {
//        if(TextUtils.isEmpty(v1)||TextUtils.isEmpty(v2)){
//            return new BigDecimal("0");
//        }
//        BigDecimal b1 = new BigDecimal(v1);
//        BigDecimal b2 = new BigDecimal(v2);
//        return b1.multiply(b2);
//    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
     *
     * @param v1
     * @param v2
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2) {
        return divide(v1, v2, DEFAULT_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
     *
     * @param v1
     * @param v2
     * @param scale 表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale) {
        return divide(v1, v2, scale, BigDecimal.ROUND_HALF_EVEN);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
     *
     * @param v1
     * @param v2
     * @param scale      表示需要精确到小数点以后几位
     * @param round_mode 表示用户指定的舍入模式
     * @return 两个参数的商
     */
    public static double divide(double v1, double v2, int scale, int round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, round_mode).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入,舍入模式采用ROUND_HALF_EVEN
     *
     * @param v1
     * @param v2
     * @return 两个参数的商，以字符串格式返回
     */
    public static String divide(String v1, String v2) {
        return divide(v1, v2, DEFAULT_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用ROUND_HALF_EVEN
     *
     * @param v1
     * @param v2
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商，以字符串格式返回
     */
    public static String divide(String v1, String v2, int scale) {
        return divide(v1, v2, DEFAULT_DIV_SCALE, BigDecimal.ROUND_HALF_EVEN);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。舍入模式采用用户指定舍入模式
     *
     * @param v1
     * @param v2
     * @param scale      表示需要精确到小数点以后几位
     * @param round_mode 表示用户指定的舍入模式
     * @return 两个参数的商，以字符串格式返回
     */
    public static String divide(String v1, String v2, int scale, int round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.divide(b2, scale, round_mode).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v          需要四舍五入的数字
     * @param scale      小数点后保留几位
     * @param round_mode 指定的舍入模式
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale, int round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        return b.setScale(scale, round_mode).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理,舍入模式采用ROUND_HALF_EVEN
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果，以字符串格式返回
     */
    public static String round(String v, int scale) {
        return round(v, scale, BigDecimal.ROUND_HALF_EVEN);
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v          需要四舍五入的数字
     * @param scale      小数点后保留几位
     * @param round_mode 指定的舍入模式
     * @return 四舍五入后的结果，以字符串格式返回
     */
    public static String round(String v, int scale, int round_mode) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, round_mode).toString();
    }

    /**
     * @param str  用于判断是否为DoubleL类型
     * @return
     */
    public static boolean isDouble(String str) {
        try {
            Double.parseDouble(str);
            return true;
        } catch (NumberFormatException ex) {
        }
        return false;
    }


    /**
     * 将每三个数字加上逗号处理,最多保留两位小数（通常使用金额方面的编辑）示例：9，702.44
     *
     * @param text
     * @return
     */
    public static String dataFormat(String text) {
        if(null==text||TextUtils.isEmpty(text)){
            return "0.00";
        }
        DecimalFormat df = null;
        if (text.indexOf(".") > 0) {//含有小数
            if (text.length() - text.indexOf(".") - 1 == 0) {//含有一位小数
                df = new DecimalFormat("###,##0.");
            } else if (text.length() - text.indexOf(".") - 1 == 1) {//含有两位小数
                df = new DecimalFormat("###,##0.0");
            } else {//含有两位以上的小数
                df = new DecimalFormat("###,##0.00");
            }
        } else {//只有整数部分
            df = new DecimalFormat("###,##0");
        }
        double number = 0.0;
        try {
            number = Double.parseDouble(text);
        } catch (Exception e) {
            number = 0.0;
        }
        return df.format(number);

    }


    public static double twoNumberDouble(String number) {
        if(TextUtils.isEmpty(number)){
            return 0.00;
        }
        try {
            BigDecimal bigDecimal = new BigDecimal(number);
            return bigDecimal.setScale(digit, BigDecimal.ROUND_HALF_UP).doubleValue();
        }catch (Exception e){
            return 0.00;
        }
    }


    //@TODO Stirng转化为double
    public static double toNumberDouble(String number) {
        if(TextUtils.isEmpty(number)){
            return 0.00;
        }
        try {
            BigDecimal bigDecimal = new BigDecimal(number);
            return bigDecimal.doubleValue();
        }catch (Exception e){
            return 0.00;
        }
    }

/*******************************************************************************/
    //@TODO 去除小数点后面多余的0 1.0---1  1.230------1.23
    public static String FilterNumOverZear(String number){
        if(TextUtils.isEmpty(number)){
            return "0";
        }
        try {
            //@TODO 这里要判断 是否等于0 如果等于0 则返回0  因为 后面去除无效0 的方法 针对0.0000 无效
            if(new BigDecimal(number).compareTo(BigDecimal.ZERO)==0){
                return "0";
            }
            String result = new BigDecimal(number).stripTrailingZeros().toPlainString();//去除多余的0
            return result;
        }catch (Exception e){
            return number;
        }

    }


    //@TODO 截取小数点指定位数  specifyTheNumberOfDigits
    public static String FilterNumSpilterOfDigits(String number){
        if(TextUtils.isEmpty(number)){
            return "0";
        }
        try {
//            double numbervalue=Double.parseDouble(number);
//            //@TODO 截取小数点4位 不需要保留小数
//            DecimalFormat df=new DecimalFormat("0.00");
//            df.setRoundingMode(RoundingMode.FLOOR);
//            return df.format(numbervalue);


            //@TODO 截取两位小数 不丢精度
            return new BigDecimal(number).setScale(2, ROUND_DOWN).toString();

        }catch (Exception e){
            return number;
        }

    }


    //@TODO 先截取指定位数 去除后面无用的0
    public static String toFilterNum(String number){
        if(TextUtils.isEmpty(number)){
            return "0";
        }
        try {
            String spilterValue= FilterNumSpilterOfDigits(number);//截取两位位
            String str=FilterNumOverZear(spilterValue);
            return str;
        }catch (Exception e){
            return number;
        }
    }

//-------------------------------------------------------
    //@TODO 截取四位小数
    public static String toFilterFourNum(String number){
        if(TextUtils.isEmpty(number)){
            return "0";
        }
        try {
            BigDecimal a = new BigDecimal(number);
            BigDecimal result = a.setScale(4, RoundingMode.DOWN);
            return result.toString();
        }catch (Exception e){
            return number;
        }
    }

    //@TODO 设置默认 0.00
    public static String toFilterDefault(String number){
        if(TextUtils.isEmpty(number)||"0".equals(number)){
            return "0.00";
        }
        return number;

    }

    //@TODO 先进行截取两位小数 去掉无效0  然后进行千分位处理
    public static String toFilterNumAndFormat(String number){
        if(TextUtils.isEmpty(number)){
            return "0";
        }
        try {
            return MathUtil.dataFormat(MathUtil.toFilterNum(number));
        }catch (Exception e){
            return number;
        }

    }


    //@TODO String 转化为 int 注意null 或者"" 空字符串的情况
    public static int StringToInt(String str){
        int intdata=0;
        if(null==str|| TextUtils.isEmpty(str)){
            return intdata;
        }
        try {
            intdata=Integer.valueOf(str).intValue();
            return  intdata;
        }catch (Exception e){
            return intdata;
        }
    }

    //@TODO String 转化为 int 注意null 或者"" 空字符串的情况
    public static long StringToLong(String str){
        long intdata=0;
        if(null==str||TextUtils.isEmpty(str)){
            return intdata;
        }
        try {
            intdata=Long.valueOf(str).longValue();

            return  intdata;
        }catch (Exception e){
            return intdata;
        }
    }






}
